package Interfaces;
import HLW;
import IA.Accion;
import IA.Estado;
import IA.MinMax;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.rms.RecordStore;

import Motor.Carta;
import Motor.Habilidad;
import Motor.Hero;
import Motor.Juego;
import Motor.ListaCartas;
import Motor.Player;

public class PantallaCarta extends Canvas {

	Figura[] almacen;
	int puntero = 0;
	Display display;
	int tipo, turno, fase;
	Figura imagen;
	Juego j;
	ListaCartas cartas;
	Player p;
	int puntCarta;

	double porcentX = (double) getWidth() / 240;
	double porcentY = (double) getHeight() / 320;
	private int mode=0;

	public PantallaCarta(Display d, Juego j, int turn, int fase, int t) {
		this.turno = turn;
		this.fase = fase;
		display = d;
		this.j = j;
		tipo = t;
		imagen = new Figura((int) ((29.0 / 240.0) * getWidth()),
				(int) ((5.0 / 320.0) * getHeight()), (int) (182 * porcentX),
				(int) (281 * porcentY));
		almacen = new Figura[2];
		almacen[0] = new Figura((int) ((155.0 / 240.0) * getWidth()),
				(int) ((286.0 / 320.0) * getHeight()), (int) (75 * porcentX),
				(int) (19 * porcentY));
		almacen[1] = new Figura((int) ((70.0 / 240.0) * getWidth()),
				(int) ((286.0 / 320.0) * getHeight()), (int) (75 * porcentX),
				(int) (19 * porcentY));

		cartas = new ListaCartas(0);

	}

	void setCarta(Carta c) {
		cartas = new ListaCartas(0);
		cartas.insertar(c);
	}

	void setTurno(int t) {
		turno = t;
	}

	void setFase(int f) {
		fase = f;
	}

	void setTipo(int t) {
		tipo = t;
	}

	PantallaCarta(Display d, int t, Juego j, Player p, RecordStore rs) {// nombre
																		// archivo
																		// y
																		// jugador
																		// en
																		// dnd
																		// insertar
		display = d;
		tipo = t;
		this.j = j;
		this.p = p;
		imagen = new Figura(29, 5, 182, 281);
		almacen = new Figura[4];
		almacen[0] = new Figura(155, 286, 75, 19);
		almacen[1] = new Figura(70, 286, 75, 19);
		almacen[2] = new Figura(10, 100, 10, 10);
		almacen[3] = new Figura(getWidth() - 20, 100, 10, 10);
		puntCarta = 0;
		if (tipo == 0) {
			try {
				ListaCartas.cargar(rs, cartas);
			} catch (Exception e) {
			}
		} else {
			cartas = p.getDeck();
			for (int i = 0; i < 4; i++) {
				cartas.insertar(p.getHeros().verCarta(i));
			}
		}
	}

	protected void paint(Graphics g) {

		Font font;
		Image image;

		porcentX = (double) getWidth() / 240;
		porcentY = (double) getHeight() / 320;

		imagen = new Figura((int) ((29.0 / 240.0) * getWidth()),
				(int) ((5.0 / 320.0) * getHeight()), (int) (182 * porcentX),
				(int) (281 * porcentY));
		almacen = new Figura[1];
		almacen = new Figura[2];
		almacen[0] = new Figura((int) ((155.0 / 240.0) * getWidth()),
				(int) ((286.0 / 320.0) * getHeight()), (int) (75 * porcentX),
				(int) (19 * porcentY));
		almacen[1] = new Figura((int) ((70.0 / 240.0) * getWidth()),
				(int) ((286.0 / 320.0) * getHeight()), (int) (75 * porcentX),
				(int) (19 * porcentY));

		// Pinto la pantalla de negro
		g.setColor(0, 0, 0);
		g.fillRect(0, 0, getWidth(), getHeight());

		// Pinto la Imagen y el boton Cancelar
		Carta c = cartas.verCarta(0);
		Image aux = Carta.scaleImage(c.getImagen(), imagen.getAncho(), imagen.getAlto());
		g.drawImage(aux, imagen.getX() + imagen.getAncho() / 2, imagen.getY() + imagen.getAlto()
				/ 2, (Graphics.VCENTER | Graphics.HCENTER));
		if (c.getTipoCarta() == 0) {// SI LA CARTA ES HERO MUESTRO SUS ATRIBUTOS
			Hero h = (Hero) c;
			font = Font.getFont(Font.FACE_MONOSPACE, Font.STYLE_BOLD,
					Font.SIZE_LARGE);
			g.setColor(0, 255, 255);
			g.drawString("" + h.getDmg(), (int) ((60.0 / 240.0) * getWidth()),
					(int) ((275.0 / 320.0) * getHeight()),
					(Graphics.BOTTOM | Graphics.HCENTER));
			g.drawString("" + h.getAtk(), (int) ((113.0 / 240.0) * getWidth()),
					(int) ((275.0 / 320.0) * getHeight()),
					(Graphics.BOTTOM | Graphics.HCENTER));
			g.drawString("" + h.getHlt(), (int) ((165.0 / 240.0) * getWidth()),
					(int) ((275.0 / 320.0) * getHeight()),
					(Graphics.BOTTOM | Graphics.HCENTER));
		}

		try {
			image = Image.createImage("/Imagenes/PCC.png");
			image = Carta.scaleImage(image, almacen[0].getAncho(), almacen[0].getAlto());
			g.drawImage(image, almacen[0].getX() + almacen[0].getAncho() / 2,
					almacen[0].getY() + almacen[0].getAlto() / 2,
					(Graphics.VCENTER | Graphics.HCENTER));
		} catch (Exception e) {
		}
		;

		// Pinto el resto de caracteristicas dependiendo de la pantalla
		switch (tipo) {
		case 0:// PARA A�ADIR CARTAS AL MAZO
				// BOTON A�ADIR
			try {
				image = Image.createImage("/Imagenes/PCA.png");
				image = Carta.scaleImage(image, almacen[1].getAncho(),
						almacen[1].getAlto());
				g.drawImage(image, almacen[1].getX() + almacen[1].getAncho() / 2,
						almacen[1].getY() + almacen[1].getAlto() / 2,
						(Graphics.VCENTER | Graphics.HCENTER));
			} catch (Exception e) {
			}
			;
			// FLEXA IZQ
			try {
				image = Image.createImage("/Imagenes/FlexaAQI.png");
				image = Carta.scaleImage(image, almacen[2].getAncho(),
						almacen[2].getAlto());
				g.drawImage(image, almacen[2].getX() + almacen[2].getAncho() / 2,
						almacen[2].getY() + almacen[2].getAlto() / 2,
						(Graphics.VCENTER | Graphics.HCENTER));
			} catch (Exception e) {
			}
			;
			// FLEXA DRCH
			try {
				image = Image.createImage("/Imagenes/FlexaAQD.png");
				image = Carta.scaleImage(image, almacen[3].getAncho(),
						almacen[3].getAlto());
				g.drawImage(image, almacen[3].getX() + almacen[3].getAncho() / 2,
						almacen[3].getY() + almacen[3].getAlto() / 2,
						(Graphics.VCENTER | Graphics.HCENTER));
			} catch (Exception e) {
			}
			;

			break;
		case 1:// PARA QUITAR CARTAS
				// BOTON QUITAR
			try {
				image = Image.createImage("/Imagenes/PCQ.png");
				g.drawImage(image, almacen[1].getX() + almacen[1].getAncho() / 2,
						almacen[1].getY() + almacen[1].getAlto() / 2,
						(Graphics.VCENTER | Graphics.HCENTER));
			} catch (Exception e) {
			}
			;
			// FLEXA IZQ
			try {
				image = Image.createImage("/Imagenes/FlexaAQI.png");
				g.drawImage(image, almacen[2].getX() + almacen[2].getAncho() / 2,
						almacen[2].getY() + almacen[2].getAlto() / 2,
						(Graphics.VCENTER | Graphics.HCENTER));
			} catch (Exception e) {
			}
			;
			// FLEXA DER
			try {
				image = Image.createImage("/Imagenes/FlexaAQD.png");
				g.drawImage(image, almacen[3].getX() + almacen[3].getAncho() / 2,
						almacen[3].getY() + almacen[3].getAlto() / 2,
						(Graphics.VCENTER | Graphics.HCENTER));
			} catch (Exception e) {
			}
			;

			// MUESTRO EL NUMERO DE CARTAS DEL MAZO Y LAS REPETICIONES DE DICHA
			// CARTA
			font = Font.getFont(Font.FACE_MONOSPACE, Font.STYLE_PLAIN,
					Font.SIZE_MEDIUM);
			g.setFont(font);
			g.setColor(0, 255, 255);
			g.drawString("" + cartas.getN(), 0, 0, (Graphics.TOP | Graphics.LEFT));
			g.drawString("" + cartas.numRepet(cartas.verCarta(puntCarta)), 0,
					10, (Graphics.TOP | Graphics.LEFT));
			break;
		case 2:// Para Jugar/Ver una Habilidad
				// SI ES LA HORA DE USAR HABILIDAD ACTIVAMOS EL BOTON
			if (fase == 1 || fase == 3) {
				try {
					image = Image.createImage("/Imagenes/PCU.png");
					image = Carta.scaleImage(image, almacen[1].getAncho(),
							almacen[1].getAlto());
					g.drawImage(image, almacen[1].getX() + almacen[1].getAncho() / 2,
							almacen[1].getY() + almacen[1].getAlto() / 2,
							(Graphics.VCENTER | Graphics.HCENTER));
				} catch (Exception e) {
				}
				;
			}
			break;
		case 3:// Para Jugar/Ver un Heroe
				// SI ES LA HORA DE USAR HEROE ACTIVAMOS EL BOTON y es nuestro
			if (fase == 0) {
				boolean b = false;
				for (int i = 0; i < j.getJugador()[turno].getHeros().getList().length; i++) {
					b = b|| j.getJugador()[turno].getHeros().getList()[i].equals(cartas
									.verCarta(0));
				}
				if (b) {
					try {
						image = Image.createImage("/Imagenes/PCU.png");
						image = Carta.scaleImage(image, almacen[1].getAncho(),
								almacen[1].getAlto());
						g.drawImage(image, almacen[1].getX() + almacen[1].getAncho() / 2,
								almacen[1].getY() + almacen[1].getAlto() / 2,
								(Graphics.VCENTER | Graphics.HCENTER));
					} catch (Exception e) {
					};
				}
			}
			break;
		}

		// Pintamos la seleccion
		g.setColor(255, 255, 0);
		g.setStrokeStyle(Graphics.DOTTED);
		g.drawRect(almacen[puntero].getX() - 2, almacen[puntero].getY() - 2,
				almacen[puntero].getAncho() + 4, almacen[puntero].getAlto() + 4);
	}

	protected void keyPressed(int keyCode) {

		if (keyCode == -1) {// arriba
			if ((fase == 0 && tipo == 3)
					|| ((fase == 1 || fase == 3) && tipo == 2)) {
				puntero = (puntero + 1) % almacen.length;
				repaint();
			}
		} else if (keyCode == -2) {// abajo
			if ((fase == 0 && tipo == 3)
					|| ((fase == 1 || fase == 3) && tipo == 2)) {
				puntero = puntero - 1;
				if (puntero == -1) {
					puntero = almacen.length - 1;
				}
				;
				repaint();
			}
		} else if (keyCode == -5) {
			switch (tipo) {
			case 0:// A�ADIR CARTA
				switch (puntero) {
				case 0:// CANCELAR
					HLW.pCM.setFullScreenMode(true);
					display.setCurrent(HLW.pCM);
					break;
				case 1:// A�ADIR
					break;
				case 2:// FLEXA IZQ
					puntCarta = puntCarta - 1;
					if (puntCarta == -1) {
						puntCarta = cartas.getN() - 1;
					}
					;
					repaint();
					break;
				case 3:// FLEXA DER
					puntCarta = (puntCarta + 1) % (cartas.getN());
					repaint();
					break;
				}
				break;
			case 1:// QUITAR CARTA
				switch (puntero) {
				case 0:// CANCELAR
					HLW.pCM.setFullScreenMode(true);
					display.setCurrent(HLW.pCM);
					break;
				case 1:// QUITAR
					break;
				case 2:// FLEXA IZQ
					puntCarta = puntCarta - 1;
					if (puntCarta == -1) {
						puntCarta = cartas.getN() - 1;
					}
					;
					repaint();
					break;
				case 3:// FLEXA DER
					puntCarta = (puntCarta + 1) % (cartas.getN());
					repaint();
					break;
				}
				break;
			case 2:// ELEGIR HABILIDAD
				switch (puntero) {
				case 0:// CANCELAR
					HLW.pJ.setFullScreenMode(true);
					display.setCurrent(HLW.pJ);
					break;
				case 1:// USAR
					Habilidad h = (Habilidad) cartas.verCarta(0);
					Hero hero = (Hero) j.getLuchador()[turno].getList().verCarta(0);
					if (fase == 1) {
						if (h.getTipo() == hero.getTipo()) {
							if (!h.isInstant()) {
								hero.setHabilidad0(h);
								hero = (Hero) j.getJugador()[turno].getHeros()
										.buscarCarta(hero.getId());
								hero.setHabilidad0(h);
								switch (puntCarta) {
								case 11:
									j.getJugador()[turno].usar(0);
									break;
								case 12:
									j.getJugador()[turno].usar(1);
									break;
								case 13:
									j.getJugador()[turno].usar(2);
									break;
								}
								puntero = 0;
								if(mode==0){
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}else if(mode==1){
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									//NOTA:
									//HASTA AKI LLEGA BIEN EL ESTADO Y SE INSERTA LA HAB 0
									//Hago llamada a la IA
									Estado e= new Estado(j, fase, turno);
									MinMax m=new MinMax(9);
									Accion c=m.minMax(turno,e);
									e=e.applyAction(c,turno);
									turno = e.getTurno();
									fase=e.getFase();
									//actualizo valores
									j.setJugador(e.getJugador());
									j.setLuchador(e.getLuchador());
									HLW.pCom.setJuego(j);
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									//aviso a pantallaPillz que es modo IA
									HLW.pCom.setMode(1);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}
							}
						}
					} else if (fase == 3) {
						if (h.getTipo() == hero.getTipo()) {
							if (h.isInstant()) {
								j.getLuchador()[turno].setHabilidad1(h);
								switch (puntCarta) {
								case 11:
									j.getJugador()[turno].usar(0);
									break;
								case 12:
									j.getJugador()[turno].usar(1);
									break;
								case 13:
									j.getJugador()[turno].usar(2);
									break;
								}
								puntero = 0;
								if(mode==0){
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}else if(mode==1){//Hago llamada a la IA
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									//Hago llamada a la IA
									Estado e= new Estado(j, fase, turno);
									MinMax m=new MinMax(9);
									Accion c=m.minMax(turno,e);
									e=e.applyAction(c,turno);
									turno = e.getTurno();
									fase=e.getFase();
									//actualizo valores
									j.setJugador(e.getJugador());
									j.setLuchador(e.getLuchador());
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									HLW.pCom.setJuego(j);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}
							}
						}
					}
					break;
				}
				break;
			case 3:// Elegir HEROE
				switch (puntero) {
				case 0:// CANCELAR
					HLW.pJ.setFullScreenMode(true);
					display.setCurrent(HLW.pJ);
					break;
				case 1:// USAR
					Hero h = (Hero) cartas.verCarta(0);
					if (h.getHlt() > 0) {
						j.getLuchador()[turno].setHero(h);
						puntero = 0;
						if(mode==0){
							// avanzo instante de juego
							turno = (turno + 1) % 2;
							if (turno == 0) {
								fase++;
							}
							HLW.pCom.setTurno(turno);
							HLW.pCom.setFase(fase);
							HLW.pCom.setMode(mode);
							HLW.pCom.setFullScreenMode(true);
							display.setCurrent(HLW.pCom);
						}else if(mode==1){
							// avanzo instante de juego
							turno = (turno + 1) % 2;
							if (turno == 0) {
								fase++;
							}
							//Hago llamada a la IA
							Estado e= new Estado(j, fase, turno);
							MinMax m=new MinMax(9);
							Accion c=m.minMax(turno,e);
							e=e.applyAction(c,turno);
							//actualizo valores
							j.setJugador(e.getJugador());
							j.setLuchador(e.getLuchador());
							turno = e.getTurno();
							fase=e.getFase();
							HLW.pCom.setTurno(turno);
							HLW.pCom.setFase(fase);
							HLW.pCom.setMode(mode);
							HLW.pCom.setJuego(j);
							HLW.pCom.setFullScreenMode(true);
							display.setCurrent(HLW.pCom);
						}
					}
					break;
				}
				break;
			case -1: //Mostrar la carta en una pantalla de combate
				HLW.pCom.setTurno(turno);
				HLW.pCom.setFase(fase);
				HLW.pCom.setFullScreenMode(true);
				display.setCurrent(HLW.pCom);
			}

		} else if (keyCode == -8) {

		}
	}

	protected void pointerPressed(int _x, int _y) {
		int aux = 0;
		boolean b = false;
		while (!b && aux < almacen.length) {
			b = almacen[aux].pertenece(_x, _y);
			aux++;
		}
		if (b) {
			aux--;
			switch (tipo) {
			case 0:// A�ADIR CARTA
				switch (aux) {
				case 0:// CANCELAR
					HLW.pCM.setFullScreenMode(true);
					display.setCurrent(HLW.pCM);
					break;
				case 1:// A�ADIR
					break;
				case 2:// FLEXA IZQ
					puntCarta = puntCarta - 1;
					if (puntCarta == -1) {
						puntCarta = cartas.getN() - 1;
					}
					;
					repaint();
					break;
				case 3:// FLEXA DER
					puntCarta = (puntCarta + 1) % (cartas.getN());
					repaint();
					break;
				}
				break;
			case 1:// QUITAR CARTA
				switch (aux) {
				case 0:// CANCELAR
					HLW.pCM.setFullScreenMode(true);
					display.setCurrent(HLW.pCM);
					break;
				case 1:// QUITAR
					break;
				case 2:// FLEXA IZQ
					puntCarta = puntCarta - 1;
					if (puntCarta == -1) {
						puntCarta = cartas.getN() - 1;
					}
					;
					repaint();
					break;
				case 3:// FLEXA DER
					puntCarta = (puntCarta + 1) % (cartas.getN());
					repaint();
					break;
				}
				break;
			case 2:// ELEGIR HABILIDAD
				switch (aux) {
				case 0:// CANCELAR
					HLW.pJ.setFullScreenMode(true);
					display.setCurrent(HLW.pJ);
					break;
				case 1:// USAR
					Habilidad h = (Habilidad) cartas.verCarta(0);
					Hero hero = (Hero) j.getLuchador()[turno].getList().verCarta(0);
					if (fase == 1) {
						if (h.getTipo() == hero.getTipo()) {
							if (!h.isInstant()) {
								hero.setHabilidad0(h);
								hero = (Hero) j.getJugador()[turno].getHeros()
										.buscarCarta(hero.getId());
								hero.setHabilidad0(h);
								switch (puntCarta) {
								case 11:
									j.getJugador()[turno].usar(0);
									break;
								case 12:
									j.getJugador()[turno].usar(1);
									break;
								case 13:
									j.getJugador()[turno].usar(2);
									break;
								}
								puntero = 0;
								if(mode==0){
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}else if(mode==1){
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									//Hago llamada a la IA
									Estado e= new Estado(j, fase, turno);
									MinMax m=new MinMax(9);
									Accion c=m.minMax(turno,e);
									e=e.applyAction(c,turno);
									turno = e.getTurno();
									fase=e.getFase();
									//actualizo valores
									j.setJugador(e.getJugador());
									j.setLuchador(e.getLuchador());
									HLW.pCom.setJuego(j);
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									//aviso a pantallaPillz que es modo IA
									HLW.pCom.setMode(1);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}
							}
						}
					} else if (fase == 3) {
						if (h.getTipo() == hero.getTipo()) {
							if (h.isInstant()) {
								j.getLuchador()[turno].setHabilidad1(h);
								switch (puntCarta) {
								case 11:
									j.getJugador()[turno].usar(0);
									break;
								case 12:
									j.getJugador()[turno].usar(1);
									break;
								case 13:
									j.getJugador()[turno].usar(2);
									break;
								}
								puntero = 0;
								if(mode==0){
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}else if(mode==1){//Hago llamada a la IA
									// avanzo instante de juego
									turno = (turno + 1) % 2;
									if (turno == 0) {
										fase++;
									}
									//Hago llamada a la IA
									Estado e= new Estado(j, fase, turno);
									MinMax m=new MinMax(9);
									Accion c=m.minMax(turno,e);
									e=e.applyAction(c,turno);
									turno = e.getTurno();
									fase=e.getFase();
									//actualizo valores
									j.setJugador(e.getJugador());
									j.setLuchador(e.getLuchador());
									HLW.pCom.setTurno(turno);
									HLW.pCom.setFase(fase);
									HLW.pCom.setMode(mode);
									HLW.pCom.setJuego(j);
									HLW.pCom.setFullScreenMode(true);
									display.setCurrent(HLW.pCom);
								}
							}
						}
					}
					break;
				}
				break;
			case 3:// Elegir HEROE
				switch (aux) {
				case 0:// CANCELAR
					HLW.pJ.setFullScreenMode(true);
					display.setCurrent(HLW.pJ);
					break;
				case 1:// USAR
					Hero h = (Hero) cartas.verCarta(0);
					if (h.getHlt() > 0) {
						j.getLuchador()[turno].setHero(h);
						puntero = 0;
						if(mode==0){
							// avanzo instante de juego
							turno = (turno + 1) % 2;
							if (turno == 0) {
								fase++;
							}
							HLW.pCom.setTurno(turno);
							HLW.pCom.setFase(fase);
							HLW.pCom.setMode(mode);
							HLW.pCom.setFullScreenMode(true);
							display.setCurrent(HLW.pCom);
						}else if(mode==1){
							// avanzo instante de juego
							turno = (turno + 1) % 2;
							if (turno == 0) {
								fase++;
							}
							//Hago llamada a la IA
							Estado e= new Estado(j, fase, turno);
							MinMax m=new MinMax(9);
							Accion c=m.minMax(turno,e);
							e=e.applyAction(c,turno);
							//actualizo valores
							j.setJugador(e.getJugador());
							j.setLuchador(e.getLuchador());
							turno = e.getTurno();
							fase=e.getFase();
							HLW.pCom.setTurno(turno);
							HLW.pCom.setFase(fase);
							HLW.pCom.setMode(mode);
							HLW.pCom.setJuego(j);
							HLW.pCom.setFullScreenMode(true);
							display.setCurrent(HLW.pCom);
						}
					}
					break;
				}
			default: //Mostrar la carta en una pantalla de combate
				HLW.pCom.setTurno(turno);
				HLW.pCom.setFase(fase);
				HLW.pCom.setFullScreenMode(true);
				display.setCurrent(HLW.pCom);
			}
		}
		repaint();
	}

	public void setPuntCarta(int i) {
		puntCarta = i;
	}

	public void setMode(int _mode) {
		mode=_mode;
	}
}
